//
//  main.m
//  算法（面试）
//
//  Created by sycjyy on 15/11/23.
//  Copyright (c) 2015年 sycjyy. All rights reserved.
//

#import <Foundation/Foundation.h>


/*
    当前已经编程实现函数int rand100(),该函数可返回0~99的随机整数，且可以保证等概率。请利用该函数实现int rand1000() ,要求等概率返回0～9999的随机数。（不可使用其他的系统函数）
 */

int rand100(){
    
    return rand()%100;
}

int rand10000(){
    return rand100() + rand100()*100;
}
/*
 汤姆现在要在家里举行宴会，他虽然有很多筷子，但这些筷子的长度并不完全相同，现已知每根筷子的长度，要求每位客人都能拿到两根长度相同的筷子，求最多可邀请的客人数。
 实现编程：int getMax(int arrLength[N]);
 */
int getMax(int arrLength[],int n){//arrLength只是传过来的地址，求大小不能用sizeof
    int s = 0;
    int arrNew[n];

    for (int i = 0; i < n; i ++) {
        arrNew[i] = arrLength[i];
    }
    //计算数组里元素的个数 用数组占的总空间大小除以一个元素的内存大小 sizeof
    unsigned long m = sizeof(arrNew)/sizeof(arrNew[0]);
    
    printf("%lu\n",m);
    for (int i = 0; i < n; i++) {
       
        for (int j = i + 1; j < n; j++) {
            if (arrLength[i] == arrLength[j] && arrLength[i] > 0) {
                printf("%d\t%d\t%d---%d\n",i,j,arrLength[i],arrLength[j]);
                s = s + 1;
                arrLength[j] = 0;
                break;
            }
        }
    }
    return s;
}

/*
 现有一个整数序列，你可以交换其中的任意两个数以得到一个新序列，求共能得到多少可能的结果，（注意：3，3，3，3 无论怎么交换，只能得到一个序列）
 编程实现：int getTotal(int arrOrigin(N));
 */

int getTotal(int arrOrigin[],int n){
    
    int s = 0;
    
    for (int i = 0 ; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arrOrigin[i] == arrOrigin[j]) {
                continue;
            }
            s = s + 1;
        }
    }
    
    return s;
}

/*
    现有一个M行N列的数组，要求按照反向斜对角线（右上-->左下）的方式，打印该数组。
    编程实现：int printMartrix[int arrMartrix[M][N]];
    下面样例的打印顺序为：0 -> 1 -> 4 -> 2 -> 5 -> 8 -> 3 -> 6 -> 9 -> 7 -> 10 -> 11
        0       1       2       3
        4       5       6       7   
        8       9       10      11
 */

int M = 3,N = 4;
int printMartrix(int arrMartrix[M][N]){
    
    for (int k = 0; k < M + N -1; k++) {
        for (int j = k, i = 0; i <= k && j >= 0 ; i++, j--) {
            if (i < M && j < N) {
                printf("%d\t",arrMartrix[i][j]);
            }
        }
    }
    return 2;
}


/*
 
 */


void GetMemory(char *p){
    p = (char *)malloc(100);
}
void test(void){
    char *str = NULL;
    GetMemory(str);
//    strcpy(str, "hello");
    printf("str---%s",str);
}

char *GetMemoryOne(void){
    char p[] = "hello world";
    return p;
}

void test1(void){
    char *str = NULL;

    str = GetMemoryOne();
    printf("str----%s",str);
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        srand((unsigned)time(NULL));
        for (int i = 0; i < 50; i++) {
            int b = rand10000();
            printf("%d\t",b);
        }
    }
    //getMax
    printf("\n\n");
    int arrLength[] = {12,10,8,11,13,12,13,12,11,14,15,13,15,11,13};
    int n = sizeof(arrLength)/sizeof(arrLength[0]);
    printf("%d\n",n);
    int conut = getMax(arrLength,n);
    printf("%d\n",conut);
    
    //getTotal
    int arrOrigin[] = {3,4,5,2};
    int m = sizeof(arrOrigin)/sizeof(arrOrigin[0]);
    int conut1 = getTotal(arrOrigin,m);
    printf("m=%d  产生的新序列count = %d\n",m,conut1);
    
    //print
    int arrMartrix[3][4] = {{0,1,2,3},{4,5,6,7},{8,9,10,11}};
    
    printMartrix(arrMartrix);
    
    
    //text
    test();
    test1();
    return 0;
}
